package com.smart.community.property.service;

import java.util.Collections;
import java.util.List;
import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.smart.community.commons.utils.RedisUtil;

import lombok.extern.slf4j.Slf4j;

/**
 * 权限缓存刷新服务
 * 用于在权限变更时自动刷新相关缓存
 * @author Wu.Liang
 * @since 2025-06-29
 */
@Slf4j
@Service
public class PermissionCacheRefreshService {

    // 缓存相关常量
    private static final String CACHE_PREFIX_PERMISSION = "permission:";
    private static final String CACHE_PREFIX_USER_SUPER_ADMIN = "user:super:admin:";
    private static final String CACHE_PREFIX_USER_DATA_SCOPE = "user:data:scope:";
    private static final String CACHE_PREFIX_USER_PROPERTY_COMPANY_IDS = "user:property:company:ids:";
    private static final String CACHE_PREFIX_USER_COMMUNITY_IDS = "user:community:ids:";

    @Autowired
    private RedisUtil redisUtil;

    @Autowired
    private PropertyCompanyPermissionCacheService permissionCacheService;

    /**
     * 刷新用户权限缓存
     * @param userId 用户ID
     */
    public void refreshUserPermissionCache(Long userId) {
        if (userId == null) {
            log.warn("用户ID为空，跳过权限缓存刷新");
            return;
        }

        log.info("刷新用户权限缓存，用户ID: {}", userId);
        
        try {
            // 清除Redis中的用户权限缓存
            clearRedisUserPermissionCache(userId);
            
            // 清除Spring Cache中的用户权限缓存
            clearSpringCacheUserPermission(userId);
            
            // 清除用户数据权限相关缓存
            permissionCacheService.clearUserPermissionCache(userId);
            
            log.info("用户权限缓存刷新完成，用户ID: {}", userId);
        } catch (Exception e) {
            log.error("刷新用户权限缓存失败，用户ID: {}", userId, e);
        }
    }

    /**
     * 刷新角色权限缓存
     * @param roleId 角色ID
     */
    public void refreshRolePermissionCache(Long roleId) {
        if (roleId == null) {
            log.warn("角色ID为空，跳过权限缓存刷新");
            return;
        }

        log.info("刷新角色权限缓存，角色ID: {}", roleId);
        
        try {
            // 获取拥有该角色的所有用户ID
            List<Long> userIds = getUsersByRole(roleId);
            
            // 刷新所有相关用户的权限缓存
            for (Long userId : userIds) {
                refreshUserPermissionCache(userId);
            }
            
            log.info("角色权限缓存刷新完成，角色ID: {}, 影响用户数: {}", roleId, userIds.size());
        } catch (Exception e) {
            log.error("刷新角色权限缓存失败，角色ID: {}", roleId, e);
        }
    }

    /**
     * 刷新社区相关权限缓存
     * @param communityId 社区ID
     */
    public void refreshCommunityPermissionCache(Long communityId) {
        if (communityId == null) {
            log.warn("社区ID为空，跳过权限缓存刷新");
            return;
        }

        log.info("刷新社区权限缓存，社区ID: {}", communityId);
        
        try {
            // 获取与该社区关联的所有用户ID
            List<Long> userIds = getUsersByCommunity(communityId);
            
            // 刷新所有相关用户的权限缓存
            for (Long userId : userIds) {
                refreshUserPermissionCache(userId);
            }
            
            log.info("社区权限缓存刷新完成，社区ID: {}, 影响用户数: {}", communityId, userIds.size());
        } catch (Exception e) {
            log.error("刷新社区权限缓存失败，社区ID: {}", communityId, e);
        }
    }

    /**
     * 刷新物业公司相关权限缓存
     * @param propertyCompanyId 物业公司ID
     */
    public void refreshPropertyCompanyPermissionCache(Long propertyCompanyId) {
        if (propertyCompanyId == null) {
            log.warn("物业公司ID为空，跳过权限缓存刷新");
            return;
        }

        log.info("刷新物业公司权限缓存，物业公司ID: {}", propertyCompanyId);
        
        try {
            // 获取与该物业公司关联的所有用户ID
            List<Long> userIds = getUsersByPropertyCompany(propertyCompanyId);
            
            // 刷新所有相关用户的权限缓存
            for (Long userId : userIds) {
                refreshUserPermissionCache(userId);
            }
            
            log.info("物业公司权限缓存刷新完成，物业公司ID: {}, 影响用户数: {}", propertyCompanyId, userIds.size());
        } catch (Exception e) {
            log.error("刷新物业公司权限缓存失败，物业公司ID: {}", propertyCompanyId, e);
        }
    }

    /**
     * 刷新所有权限缓存
     */
    public void refreshAllPermissionCache() {
        log.info("刷新所有权限缓存");
        
        try {
            // 清除所有Redis中的权限相关缓存
            clearAllRedisPermissionCache();
            
            // 清除所有Spring Cache中的权限缓存
            clearAllSpringCachePermission();
            
            // 清除所有本地权限缓存
            permissionCacheService.clearAllPermissionCache();
            
            log.info("所有权限缓存刷新完成");
        } catch (Exception e) {
            log.error("刷新所有权限缓存失败", e);
        }
    }

    /**
     * 获取缓存统计信息
     */
    public void getCacheStatistics() {
        log.info("=== 权限缓存统计 ===");
        
        try {
            // 获取Redis缓存统计
            Set<String> permissionKeys = redisUtil.keys(CACHE_PREFIX_PERMISSION + "*");
            Set<String> userSuperAdminKeys = redisUtil.keys(CACHE_PREFIX_USER_SUPER_ADMIN + "*");
            Set<String> userDataScopeKeys = redisUtil.keys(CACHE_PREFIX_USER_DATA_SCOPE + "*");
            Set<String> userPropertyCompanyKeys = redisUtil.keys(CACHE_PREFIX_USER_PROPERTY_COMPANY_IDS + "*");
            Set<String> userCommunityKeys = redisUtil.keys(CACHE_PREFIX_USER_COMMUNITY_IDS + "*");
            
            log.info("Redis权限缓存统计:");
            log.info("  权限缓存键数量: {}", permissionKeys != null ? permissionKeys.size() : 0);
            log.info("  用户超级管理员缓存键数量: {}", userSuperAdminKeys != null ? userSuperAdminKeys.size() : 0);
            log.info("  用户数据权限缓存键数量: {}", userDataScopeKeys != null ? userDataScopeKeys.size() : 0);
            log.info("  用户物业公司权限缓存键数量: {}", userPropertyCompanyKeys != null ? userPropertyCompanyKeys.size() : 0);
            log.info("  用户社区权限缓存键数量: {}", userCommunityKeys != null ? userCommunityKeys.size() : 0);
            
            // 获取本地缓存统计
            permissionCacheService.getCacheStatistics();
        } catch (Exception e) {
            log.warn("获取Redis缓存统计失败", e);
        }
    }

    /**
     * 获取拥有指定角色的用户ID列表
     * @param roleId 角色ID
     * @return 用户ID列表
     */
    private List<Long> getUsersByRole(Long roleId) {
        log.debug("获取拥有角色的用户，角色ID: {}", roleId);
        // 这里需要调用用户角色关联服务来获取
        // 暂时返回空列表，实际实现时需要注入相关服务
        return Collections.emptyList();
    }

    /**
     * 获取与社区关联的用户ID列表
     * @param communityId 社区ID
     * @return 用户ID列表
     */
    private List<Long> getUsersByCommunity(Long communityId) {
        log.debug("获取与社区关联的用户，社区ID: {}", communityId);
        // 这里需要调用社区服务来获取
        // 暂时返回空列表，实际实现时需要注入相关服务
        return Collections.emptyList();
    }

    /**
     * 获取与物业公司关联的用户ID列表
     * @param propertyCompanyId 物业公司ID
     * @return 用户ID列表
     */
    private List<Long> getUsersByPropertyCompany(Long propertyCompanyId) {
        log.debug("获取与物业公司关联的用户，物业公司ID: {}", propertyCompanyId);
        // 这里需要调用用户物业公司关联服务来获取
        // 暂时返回空列表，实际实现时需要注入相关服务
        return Collections.emptyList();
    }

    /**
     * 清除Redis中的用户权限缓存
     * @param userId 用户ID
     */
    private void clearRedisUserPermissionCache(Long userId) {
        try {
            String[] keys = {
                    CACHE_PREFIX_USER_SUPER_ADMIN + userId,
                    CACHE_PREFIX_USER_DATA_SCOPE + userId,
                    CACHE_PREFIX_USER_PROPERTY_COMPANY_IDS + userId,
                    CACHE_PREFIX_USER_COMMUNITY_IDS + userId
            };
            
            for (String key : keys) {
                redisUtil.delete(key);
                log.debug("清除Redis缓存: {}", key);
            }
            
            log.debug("清除Redis用户数据权限缓存，数量: {}", keys.length);
        } catch (Exception e) {
            log.warn("清除Redis用户权限缓存失败，用户ID: {}", userId, e);
        }
    }

    /**
     * 清除Spring Cache中的用户权限缓存
     * @param userId 用户ID
     */
    private void clearSpringCacheUserPermission(Long userId) {
        try {
            // 这里需要根据实际的Spring Cache配置来实现
            // 暂时记录日志，实际实现时需要注入CacheManager
            log.debug("清除Spring Cache用户权限缓存，用户ID: {}", userId);
        } catch (Exception e) {
            log.warn("清除Spring Cache用户权限缓存失败，用户ID: {}", userId, e);
        }
    }

    /**
     * 清除所有Redis中的权限相关缓存
     */
    private void clearAllRedisPermissionCache() {
        try {
            Set<String> keys = redisUtil.keys(CACHE_PREFIX_PERMISSION + "*");
            if (keys != null && !keys.isEmpty()) {
                for (String key : keys) {
                    redisUtil.delete(key);
                }
                log.debug("清除Redis权限缓存，数量: {}", keys.size());
            }
        } catch (Exception e) {
            log.warn("清除所有Redis权限缓存失败", e);
        }
    }

    /**
     * 清除所有Spring Cache中的权限缓存
     */
    private void clearAllSpringCachePermission() {
        try {
            // 这里需要根据实际的Spring Cache配置来实现
            log.debug("清除所有Spring Cache权限缓存");
        } catch (Exception e) {
            log.warn("清除所有Spring Cache权限缓存失败", e);
        }
    }
}
